'Git pull' ve 'git fetch' arasındaki fark nedir?

1
2
Sonraki
En basit ifadeyle, git pull bir git getirme ve ardından git birleştirme yapar.
Uzaktan takip şubelerinizi refs / remotes /  / altında güncellemek için istediğiniz zaman git getirme işlemi yapabilirsiniz.
Bu işlem, referanslar / başlıklar altında kendi yerel şubelerinizden hiçbirini asla değiştirmez ve çalışma kopyanızı değiştirmeden yapmak güvenlidir. Hatta arka planda bir cron işinde git getirme işlemini düzenli olarak çalıştıran insanları duydum (ancak bunu yapmanızı tavsiye etmiyorum).
Git çekme, yerel bir şubeyi uzak sürümüyle güncellerken diğer uzaktan izleme şubelerinizi de güncellemek için yapacağınız şeydir.
Git pull için Git belgelerinden:
Varsayılan modunda git çekme, git getirmenin kısaltmasıdır ve bunu git merge FETCH_HEAD izler.
|
Çek'i kullandığınızda Git, işinizi sizin için otomatik olarak yapmaya çalışır. İçeriğe duyarlıdır, bu nedenle Git, çekilen tüm taahhütleri şu anda çalıştığınız dalda birleştirir. Çekme, taahhütleri önce incelemenize izin vermeden otomatik olarak birleştirir. Şubelerinizi yakından yönetmezseniz, sık sık çatışmalarla karşılaşabilirsiniz.
Getirdiğinizde, Git mevcut şubenizde bulunmayan tüm işlemleri hedef şubeden toplar ve yerel deponuzda saklar. Ancak, bunları mevcut şubenizle birleştirmez. Bu, özellikle deponuzu güncel tutmanız gerekiyorsa, ancak dosyalarınızı güncellerseniz bozulabilecek bir şey üzerinde çalışıyorsanız yararlıdır.
İşlemleri ana şubenize entegre etmek için birleştirmeyi kullanırsınız.
|
Git tasarım felsefesini, SVN gibi daha geleneksel bir kaynak kontrol aracının felsefesiyle karşılaştırmak önemlidir.
Subversion, bir istemci / sunucu modeli ile tasarlanmış ve oluşturulmuştur. Sunucu olan tek bir depo vardır ve birkaç istemci sunucudan kod alabilir, üzerinde çalışabilir ve ardından sunucuya geri yükleyebilir. Varsayım, istemcinin bir işlem gerçekleştirmesi gerektiğinde her zaman sunucuyla iletişim kurabileceğidir.
Git, merkezi bir depoya ihtiyaç duymadan daha dağıtılmış bir modeli desteklemek için tasarlandı (yine de isterseniz kesinlikle kullanabilirsiniz). Ayrıca git, istemcinin ve "sunucunun" aynı anda çevrimiçi olması gerekmeyecek şekilde tasarlanmıştır. Git, güvenilmez bir bağlantıdaki kişilerin e-posta yoluyla bile kod alışverişi yapabilmesi için tasarlandı. Tamamen bağlantısız çalışmak ve git üzerinden kod alışverişi yapmak için bir CD yazmak mümkündür.
Bu modeli desteklemek için git, kodunuzla birlikte bir yerel depo ve ayrıca uzak deponun durumunu yansıtan ek bir yerel depo tutar. Uzak deponun bir kopyasını yerel olarak saklayarak git, uzak depoya ulaşılamadığında bile gerekli değişiklikleri anlayabilir. Daha sonra değişiklikleri bir başkasına göndermeniz gerektiğinde git, bunları uzak deponun bildiği bir zamandan bir dizi değişiklik olarak aktarabilir.
git fetch, "uzak deponun yerel kopyasını güncel hale getir" yazan komuttur.
git pull "uzak depodaki değişiklikleri kendi kodumu sakladığım yere getir" diyor.
Normalde git pull bunu, uzak deponun yerel kopyasını güncellemek için bir git getirme yaparak ve ardından değişiklikleri kendi kod deponuza ve muhtemelen çalışma kopyanıza birleştirerek yapar.
Çıkarılacak şey, iş istasyonunuzda genellikle bir projenin en az üç kopyasının bulunduğunu akılda tutmaktır. Bir kopya, kendi kaydetme geçmişinize sahip kendi deponuzdur. İkinci kopya, düzenlediğiniz ve oluşturduğunuz çalışma kopyanızdır. Üçüncü kopya, uzak bir deponun yerel "önbelleğe alınmış" kopyasıdır.
|
İşte Oliver Steele'in tüm bunların nasıl birbirine uyduğuna dair görüntüsü:
Yeterli ilgi varsa, git clone ve git merge eklemek için resmi güncelleyebilirim sanırım ...
|
Git getirmenin bir kullanım durumu, aşağıdakilerin size son çekişinizden bu yana uzak daldaki herhangi bir değişikliği söyleyeceğidir ... böylece mevcut dalınızdaki ve çalışma kopyanızdaki dosyaları değiştirebilecek gerçek bir çekme yapmadan önce kontrol edebilirsiniz.
git getir
git fark ... kökeni
Diff komutundaki çift ve üç nokta sözdizimiyle ilgili https://git-scm.com/docs/git-diff sayfasına bakın
|
Farkın ne olduğunu anlamak bana biraz pahalıya mal oldu, ama bu basit bir açıklama. localhost'unuzdaki master bir daldır.
Bir depoyu klonladığınızda, tüm depoyu yerel ana makinenize getirirsiniz. Bu, o anda HEAD için bir başlangıç ​​/ ana işaretçiniz olduğu ve aynı KAFA'yı gösteren ana işaretçiniz olduğu anlamına gelir.
Çalışmaya başladığınızda ve taahhütlerinizi yaptığınızda, ana işaretçiyi HEAD + sizin taahhütlerinize ilerletirsiniz. Ancak, başlangıç ​​/ ana işaretçi hala klonladığınızda ne olduğunu gösteriyor.
Yani fark şu olacak:
Git getirme işlemi yaparsanız, uzak depodaki (GitHub) tüm değişiklikleri alır ve kaynak / ana işaretçiyi HEAD'e taşır. Bu arada yerel şube yöneticiniz, nerede olduğunu göstermeye devam edecektir.
Git çekme işlemi yaparsanız, temel olarak (daha önce açıklandığı gibi) getirecek ve yeni değişiklikleriana dalı seçin ve işaretçiyi HEAD'e taşıyın.
|
Bazen görsel bir temsil yardımcı olur.
|
Kısaca
git fetch, çekmeye benzer ancak birleştirme yapmaz. ör. uzak güncellemeleri alır (referanslar ve nesneler) ancak yereliniz aynı kalır (yani, kaynak / ana birim güncellenir ancak ana birim aynı kalır).
git pull bir uzaktan kumandadan aşağı çeker ve anında birleşir.
Daha
git clone bir depoyu klonlar.
git rebase, mevcut şubenizdeki yukarı akış şubesinde olmayan şeyleri geçici bir alana kaydeder. Şubeniz artık değişikliklerinize başlamadan önceki ile aynıdır. Böylece, git pull -rebase uzaktaki değişiklikleri aşağı çekecek, yerel şubenizi geri saracak, güncel olana kadar değişikliklerinizi mevcut şubenizin üstünden tek tek yeniden yayınlayacaktır.
Ayrıca git branch -a, yerel ve uzak tüm şubelerinizde tam olarak neler olduğunu size gösterecektir.
Bu blog yazısı faydalı oldu:
Git çekme, git getirme ve git klonlama (ve git rebase) arasındaki fark - Mike Pearce
ve git pull, git fetch, git clone ve git rebase'i kapsar.
====
GÜNCELLEME
Bunu pratikte nasıl kullanacağınızı göstermek için bunu güncelleyeceğimi düşündüm.
Yerel deponuzu uzaktan kumandadan güncelleyin (ancak birleştirmeyin):
git getir
Güncellemeleri indirdikten sonra farklılıkları görelim:
git diff ana kaynağı / ana
Bu güncellemelerden memnunsanız, şunları birleştirin:
git çekme
Notlar:
2. adımda: Yerel ve uzaktaki farklar hakkında daha fazla bilgi için bkz: Yerel bir git dalı uzak dalıyla nasıl karşılaştırılır?
3. adımda: Burada bir git rebase kaynağı yapmak muhtemelen daha doğrudur (örn. Hızlı değişen bir repo üzerinde). Başka bir cevapta @Justin Ohms yorumuna bakın.
Ayrıca bkz .: http://longair.net/blog/2009/04/16/git-fetch-and-merge/
|
git-pull - Başka bir depodan veya yerel bir şubeden getirme ve birleştirme
SİNOPSİS
git çek…
AÇIKLAMA
Git-fetch'i verilen parametrelerle çalıştırır ve git-merge çağırarak
mevcut şubeye alınan başlık (lar). --Rebase ile git-rebase'i çağırır
git-merge yerine.
Kullanabileceğinizi unutmayın. (geçerli dizin)  olarak çekilecek
yerel depodan - bu, yerel şubeleri birleştirirken kullanışlıdır
mevcut şubeye.
Ayrıca git-pull'ın kendisi ve temelde git-merge için olan seçeneklerin
git-fetch ile ilgili seçeneklerden önce verilmelidir.
Geçmişlerin birleştirilmesini istiyorsanız çekersiniz, birileri buralarda bazı makaleleri etiketlediği için sadece 'codez'u istiyorsanız' alırsınız.
|
Uzak bir depodan getirebilir, farkları görebilir ve sonra çekebilir veya birleştirebilirsiniz.
Bu, kaynak adı verilen bir uzak depoya ve uzak şube kaynağını / yöneticiyi izleyen ana birim adı verilen bir şubeye bir örnektir:
git ödeme yöneticisi
git getir
git fark kaynağı / ana
git rebase kaynak yöneticisi
|
Kısa ve kolay cevap, git pull'un basitçe git fetch ve ardından git merge olmasıdır.
Git pull'un beğenseniz de beğenmeseniz de otomatik olarak birleşeceğini unutmamak çok önemlidir. Bu, elbette, birleştirme çatışmalarına neden olabilir. Diyelim ki uzaktan kumandanız orijin ve şubeniz master. Çekmeden önce diff origin / master'a gittiyseniz, potansiyel birleştirme çatışmaları hakkında bir fikriniz olmalı ve yerel şubenizi buna göre hazırlayabilirsiniz.
Çekme ve itmeye ek olarak, bazı iş akışları, bunun gibi, bağlantılı makaleden açıkladığım gibi git rebase içerir:
git çekme kaynağı yöneticisi
git checkout foo-şube
git rebase yöneticisi
git itme kökeni foo-branch
Kendinizi böyle bir durumda bulursanız, git pull --rebase için cazip olabilirsiniz. Gerçekten ne yaptığını gerçekten bilmiyorsan, buna karşı tavsiye ederim. Bu uyarı git-pull sürüm 2.3.5'in man sayfasındandır:
Bu, potansiyel olarak tehlikeli bir çalışma şeklidir. Yeniden yazıyor
tarih, bu tarihi yayınladığınızda pek de iyiye işaret etmiyor
zaten. Git-rebase (1) okumadıkça bu seçeneği kullanmayın
dikkatli.
|
Tamam, işte git çekme ve git getirme hakkında bazı bilgiler, böylece gerçek farklılıkları anlayabilirsiniz ... birkaç basit kelimeyle, getir en son verileri alır, ancak kod değişikliklerini almaz ve mevcut yerel şube kodunuzla karışmaz , ancak kod değişikliklerini alın ve yerel şubenizde birleştirin, her biri hakkında daha fazla ayrıntı almak için okumaya devam edin:
git getir
Tüm referansları ve nesneleri ve yeni dalları yerel Deponuza indirecektir ...
Bir veya daha fazla şubeden dalları ve / veya etiketleri (topluca "ref") alın
diğer havuzlar ve bunların tamamlanması için gerekli nesneler
geçmişleri. Uzaktan takip şubeleri güncellenir (açıklamaya bakın
Bu davranışı kontrol etmenin yolları için aşağıda).
Varsayılan olarak, getirilen geçmişlere işaret eden herhangi bir etiket
ayrıca getirildi; etkisi, dallara işaret eden etiketleri getirmektir.
ilgileniyorsunuz. Bu varsayılan davranış, kullanılarak değiştirilebilir
--tags veya --no-tags seçenekleri veya yapılandırarak
remote..tagOpt. Etiketleri açıkça getiren bir refspec kullanarak,
ilgilendiğiniz dalları göstermeyen etiketleri getirebilirsiniz
içinde de.
git getirme şuradan getirilebilirya tek bir adlandırılmış depo ya da URL ya da
birden fazla depodan bir kerede verilirse ve bir
uzaktan kumandalar. konfigürasyon dosyasındaki giriş. (Git-config1'e bakın).
Uzaktan kumanda belirtilmediğinde, varsayılan olarak uzak konum
mevcut için yapılandırılmış bir yukarı akış şubesi olmadığı sürece kullanılır
şube.
Nesne isimleriyle birlikte getirilen referansların isimleri
işaret ederler, .git / FETCH_HEAD olarak yazılırlar. Bu bilgi olabilir
komut dosyaları veya git-pull gibi diğer git komutları tarafından kullanılır.
git çekme
Yereldeki değişiklikleri uzaktan geçerli şubeye uygulayacaktır ...
Uzak bir depodaki değişiklikleri geçerli şubeye dahil eder.
Varsayılan modunda git çekme, git getirmenin kısaltmasıdır ve ardından
git merge FETCH_HEAD.
Daha doğrusu git pull, git fetch'i verilen parametrelerle çalıştırır ve
geri alınan dal başlıklarını geçerli ile birleştirmek için git merge çağırır
şube. --Rebase ile git merge yerine git rebase çalıştırır.
aktarıldığı şekliyle uzak bir deponun adı olmalıdır
git-getirme1. rastgele bir uzak referansı adlandırabilir (örneğin,
bir etiketin adı) veya hatta karşılık gelen bir referans koleksiyonu
uzaktan izleme dalları (ör. refs / Heads /: refs / remotes / origin /),
ancak genellikle uzak depodaki bir dalın adıdır.
İçin varsayılan değerler ve buradan okunur.
Geçerli dal için "uzak" ve "birleştirme" yapılandırması tarafından ayarlandığı şekilde
git-branch --track.
Git fetch ve git'in nasıl birlikte çalıştığını göstermek için aşağıdaki görseli de oluşturuyorum ...
|
Bu etkileşimli grafik gösterim, git'i anlamada çok yararlıdır: http://ndpsoftware.com/git-cheatsheet.html
git fetch yalnızca değişiklikleri uzaktan kumandadan yerel deponuza "indirir". git pull değişiklikleri indirir ve mevcut şubenizle birleştirir. "Varsayılan modunda git çekme, git getirmenin kısaltmasıdır ve ardından git merge FETCH_HEAD gelir."
|
Bonus:
Yukarıdaki cevaplarda çek ve getir derken ilginç bir numara paylaşmak isterim,
git çekme --rebase
Yukarıdaki bu komut benim git hayatımda çok zaman kazandıran en kullanışlı komuttur.
Yeni kayıtlarınızı sunucuya göndermeden önce, bu komutu deneyin ve en son sunucu değişikliklerini otomatik olarak senkronize edecek (bir getir + birleştirme ile) ve kaydetme işleminizi git günlüğünde en üste yerleştirecektir. Manuel çekme / birleştirme konusunda endişelenmenize gerek yok.
Ayrıntıları şu adreste bulabilirsiniz: http://gitolite.com/git-pull--rebase
|
Bu şeyleri kavramak için durumun görsel bir temsiline sahip olmayı seviyorum. Belki diğer geliştiriciler de görmek isterler, işte benim eklemem. Her şeyin doğru olduğundan tam olarak emin değilim, bu yüzden herhangi bir hata bulursanız lütfen yorum yapın.
YEREL SİSTEM
. ================================================ ===
=================. ================= =================== ===============
UZAKTAN DEPOLAMA. UZAKTAN DEPO YEREL DEPO ÇALIŞMA KOPYASI
(MENŞEİ)          . (CACHED)
Örneğin,      . aynası
bir github deposu. . uzak depo
Ayrıca olabilir       .
çoklu depo.
.
.
FETCH * ------------------> *
Uzaktan kumandanın yerel önbelleğiniz başlangıç ​​noktasıyla (veya birden çok
dış kaynaklar, yani git'in dağıtılmış yapısı)
.
ÇEK   *------------------------------------------------ --------> *
değişiklikler doğrudan yerel kopyanızda birleştirilir. çatışmalar olduğunda,
kararlar isteniyor.
.
COMMIT. * <--------------- *
Örneğin yıkıcılıktan geldiğinizde, bir taahhüdün
kaynağı güncelleyecektir. Git'te, yalnızca yerel deponuza bir commit yapılır.
.
İTME * <--------------------------------------- *
Değişikliklerinizi başlangıç ​​noktasına senkronize eder.
Uzaktan kumandanın bir aynasına sahip olmanın bazı önemli avantajları şunlardır:
Performans (ağda sıkıştırmaya çalışmadan tüm taahhütleri ve mesajları kaydırın)
Yerel deponuzun durumu hakkında geri bildirim (örneğin, Atlassian'ın SourceTree'sini kullanıyorum, bu bana menşe ile karşılaştırıldığında ileride mi yoksa geride mi taahhüt ettiğimi gösteren bir ampul verecek. Bu bilgi GIT FETCH ile güncellenebilir).
|
Bununla da mücadele ettim. Aslında, tam olarak aynı soruyu içeren bir Google aramasıyla buraya geldim. Tüm bu cevapları okumak sonunda kafamda bir resim çizdi ve 2 depo ve 1 sandbox'ın durumuna ve bunların versiyonunu izlerken zamanla gerçekleştirilen eylemlere bakarak bunu anlamaya çalıştım. İşte bulduğum şey şu. Herhangi bir yeri batırırsam lütfen beni düzeltin.
Getirilen üç depo:
--------------------- ----------------------- ------ -----------------
- Uzaktan Repo - - Uzaktan Repo - - Uzaktan Repo -
- - - itilir - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------------------------------
- Yerel Repo - - Yerel Repo - - Yerel Repo -
- çek - - - - getir -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Yerel Sandbox - - Yerel Sandbox - - Yerel Sandbox -
- Ödeme - - yeni yapılan iş - - -
- @ R01 - - @ R01 + - - @ R01 + -
--------------------- ----------------------- ------ -----------------
Çekmeli üç depo
--------------------- ----------------------- ------ -----------------
- Uzaktan Repo - - Uzaktan Repo - - Uzaktan Repo -
- - - itilir - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Yerel Repo - - Yerel Repo - - Yerel Repo -
- çek - - - - çek -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Yerel Sandbox - - Yerel Sandbox - - Yerel Sandbox -
- Ödeme - - yeni yapılan iş - - R02 ile birleştirildi -
- @ R01 - - @ R01 + - - @ R02 + -
--------------------- ----------------------- ------ -----------------
Bu, getirmenin neden oldukça önemli olduğunu anlamama yardımcı oldu.
|
GIT Getirme ve GIT Çekme arasındaki fark aşağıdaki senaryo ile açıklanabilir:
(Resimlerin kelimelerden daha yüksek sesle konuştuğunu unutmayarak! Resimli sunum sağladım)
Takım üyelerinizle bir proje üzerinde çalıştığınıza bir örnek verelim. Böylece, projenin bir ana Şubesi olacak ve tüm katkıda bulunanlar, onu kendi yerel depolarına çatallaştırmalı ve ardından bu yerel şubede modülleri değiştirmek / eklemek için çalışmalı ve ardından ana şubeye geri göndermelidir.
Yani,
Ana projeyi yerel deponuzda çatalladığınızda iki Dalın Başlangıç ​​Durumu şöyle olacaktır- (A, B ve C, projenin halihazırda tamamlanmış modülleridir)
Şimdi, yeni modül üzerinde çalışmaya başladınız (D'yi varsayalım) ve D modülünü tamamladığınızda, onu ana şubeye itmek istiyorsunuz, ancak bu arada, ekip arkadaşlarınızdan biri yeni Modül E, F ve değiştirilmiş C.
Öyleyse şimdi olan şey, yerel deponuzun projenin orijinal ilerlemesinin gerisinde olmamasıdır ve bu nedenle değişikliklerinizin ana şubeye itilmesi çatışmaya yol açabilir ve Modül D'nizin arızalanmasına neden olabilir.
Bu tür sorunları önlemek ve projenin orijinal ilerlemesiyle paralel çalışmak için iki yol vardır:
1. Git Fetch- Bu, yerel şubenizde olmayan kaynak / ana şube projesinde yapılan tüm değişiklikleri indirecektir. Ve Deponuza veya şubenize getirilen değişiklikleri uygulamak için Git Birleştirme komutunu bekleyecektir.
Artık, deponuza birleştirmeden önce dosyaları dikkatlice izleyebilirsiniz. Ayrıca, Değiştirilmiş C nedeniyle gerekirse D'yi de değiştirebilirsiniz.
2. Git Pull- Bu, yerel şubenizi orijin / ana dal ile günceller, yani aslında yaptığı şey Git Fetch ve Git'in birbiri ardına birleşmesidir.
Ancak bu, Çakışmaların ortaya çıkmasına neden olabilir, bu nedenle Git Pull'u temiz bir kopya ile kullanmanız önerilir.
|
Basitçe diyoruz:
git çekme == git getir + git birleştirme
Git pull çalıştırırsanız, verileri yerel olarak birleştirmenize gerek yoktur. Git fetch çalıştırırsanız, en son kodu yerel makinenize almak için git merge çalıştırmanız gerektiği anlamına gelir. Aksi takdirde, yerel makine kodu birleştirilmeden değiştirilmeyecektir.
Yani Git Gui'de, getirdiğinizde, verileri birleştirmeniz gerekir. Getir, kendi yerel bölgenizde kod değişikliklerini yapmaz. Getirerek kodu güncellediğinizde kontrol edebilirsiniz.
bir kez getir ve gör; kod değişmeyecek. Sonra birleştirirsin ... Değiştirilen kodu göreceksin.
|
git fetch, kodu uzak sunucudan yerel deponuzdaki izleme dallarınıza indirir. Uzaktan kumandanız orijin olarak adlandırılmışsa (varsayılan), bu şubeler orijin / içinde olacaktır, örneğin orijin / ana, menşe / şubem-123 vb. Bunlar sizin mevcut şubeleriniz değil, bu şubelerin sunucudan yerel kopyaları .
git pull bir git getirme işlemi yapar, ancak aynı zamanda izleme dalındaki kodu şu anki kodunuzla birleştiriro şubenin yerel versiyonu. Henüz bu değişikliklere hazır değilsen, önce git getir.
|
git fetch uzak dalları alır, böylece git diff veya git bunları geçerli dalla birleştirebilirsiniz. git pull, geçerli dal tarafından izlenen uzak brach üzerinde getirmeyi çalıştıracak ve ardından sonucu birleştirecektir. Yerel şubenizle birleştirmeye gerek kalmadan uzak dalda herhangi bir güncelleme olup olmadığını görmek için git fetch'i kullanabilirsiniz.
|
Git Getirme
Yerel şubenizdeki değişiklikleri kökeninden getirmeye kadar indirirsiniz. Fetch, uzak depodan başkalarının yaptığı ancak yerel deponuzda olmayan tüm taahhütleri sorar. Getir, bu commit'leri indirir ve yerel depoya ekler.
Git Birleştirme
Birleştirme komutunu kullanarak getirme yoluyla indirilen değişiklikleri uygulayabilirsiniz. Birleştirme, getirme işleminden alınan taahhütleri alacak ve bunları yerel şubenize eklemeye çalışacaktır. Birleştirme, şubenizi push ile paylaştığınızda, Git başkalarının değişikliklerinizi nasıl birleştirebileceğini bilecek şekilde yerel değişikliklerinizin kayıt geçmişini tutacaktır.
Git Çekme
Getirme ve birleştirme, ikisini birleştiren bir komutun oluşturulmasına yetecek kadar sık ​​çalışır. Pull bir getirme yapar ve ardından indirilen işlemleri yerel şubenize eklemek için birleştirme yapar.
|
Basit bir ifadeyle, eğer herhangi bir internet bağlantısı olmayan bir uçağa atlamak üzereyseniz ... ayrılmadan önce, git getirme orijini  yapabilirsiniz. Tüm değişiklikleri bilgisayarınıza alır, ancak onu yerel geliştirme / çalışma alanınızdan ayrı tutar.
Düzlemde, yerel çalışma alanınızda değişiklikler yapabilir ve ardından bunu getirdiklerinizle birleştirebilir ve olası birleştirme çatışmalarını İnternet bağlantısı olmadan çözebilirsiniz. Ve birisi uzak depoda yeni değişiklikler yapmadıysa, hedefe vardığınızda git push origin  yapıp kahvenizi alırsınız.
Bu harika Atlassian öğreticisinden:
Git fetch komutu, bir
uzak depoyu yerel deponuza yerleştirin.
Getirmek, herkesin sahip olduğu şeyleri görmek istediğinizde yaptığınız şeydir
üzerinde çalışıyor. Görmenizi sağlaması açısından SVN güncellemesine benzer
merkezi tarih nasıl ilerledi, ancak sizi buna zorlamaz
aslında değişiklikleri deponuza birleştirin. Git izolatları
içeriği mevcut yerel içerikten getirildi, kesinlikle
yerel geliştirme çalışmanız üzerinde hiçbir etkisi yoktur. Getirilen içeriğin git checkout komutu kullanılarak açıkça kontrol edilmesi gerekir. Bu yapar
entegre etmeden önce taahhütleri gözden geçirmenin güvenli bir yolunu bulmak
yerel deponuz.
Uzak bir depodan içerik indirirken, görevi gerçekleştirmek için git pull ve git fetch komutları kullanılabilir. Düşünebilirsin
git iki komutun 'güvenli' versiyonunu getirir. İndirecek
uzak içerik, ancak yerel deponuzun çalışma durumunu güncellemeyin,
Mevcut çalışmanızı olduğu gibi bırakmak. git çekme daha agresif
alternatif, aktif yerel için uzak içeriği indirecek
dal ve bir birleştirme kaydı oluşturmak için hemen git birleştirmeyi yürütün
yeni uzak içerik için. Devam eden değişiklikleriniz varsa
bu, çatışmalara neden olacak ve birleştirme anlaşmazlığı çözümünü başlatacaktır
akış.
Git çekme ile:
İzolasyonunuz yok.
Açıkça kontrol edilmesine gerek yoktur. Çünkü dolaylı olarak git birleştirme yapar.
Birleştirme adımı yerel gelişiminizi etkileyecek ve çatışmalara neden olabilir
Temelde güvenli DEĞİLDİR. Agresif.
Git getirmenin yalnızca .git / refs / uzaktan kumandalarınızı etkilediği durumdan farklı olarak, git çekme hem .git / refs / remotes hem de .git / refs / heads /
Hmmm ... öyleyse, çalışma kopyasını git fetch ile güncellemiyorsam, o zaman nerede değişiklik yapıyorum? Git getirmesi yeni taahhütleri nerede saklar?
Harika soru. Onu çalışma kopyanızdan izole bir yere koyar. Ama yine nerede? Hadi bulalım.
Proje dizininizde (yani git komutlarınızı yaptığınız yerde) şunları yapın:
ls. Bu, dosyaları ve dizinleri gösterecektir. Hiç hoş değil, biliyorum.
Şimdi ls -a yapın. Bu, nokta dosyalarını, yani ile başlayan dosyaları gösterecektir. Daha sonra .git adlı bir dizini görebileceksiniz.
Cd .git yapın. Bu açıkça dizininizi değiştirecektir.
Şimdi işin eğlenceli kısmı geliyor; do ls. Bir dizin listesi göreceksiniz. Referans arıyoruz. CD referansları yapın.
Tüm dizinlerin içinde ne olduğunu görmek ilginç, ancak ikisine odaklanalım. kafalar ve uzaktan kumandalar. Bunların içini de kontrol etmek için cd kullanın.
Yaptığınız herhangi bir git getirme işlemi /.git/refs/remotes dizinindeki öğeleri güncelleyecektir. /.Git/refs/heads dizinindeki hiçbir şeyi güncellemez.
Herhangi bir git çekme işlemi önce git getirmeyi gerçekleştirecek, /.git/refs/remotes dizinindeki öğeleri güncelleyecek, ardından yerelinizle birleşecek ve ardından /.git/refs/heads dizini içindeki başlığı değiştirecektir.
Bununla ilgili çok iyi bir yanıt, 'git getirme' kendisini nereye yerleştiriyor? Bölümünde de bulunabilir.
Ayrıca, Git dal adlandırma kuralları gönderisinden "Eğik çizgi gösterimi" ni arayın. Git'in nesneleri nasıl yerleştirdiğini daha iyi anlamanıza yardımcı olurfarklı dizinler.
Gerçek farkı görmek için
Sadece yap:
git kaynak ana getirme
git ödeme yöneticisi
Uzak ana bilgisayar güncellendiyse, şöyle bir mesaj alırsınız:
Şubeniz 2 kaydetme ile 'menşe / ana' gerisinde ve hızlı ileri sarılabilir.
(yerel şubenizi güncellemek için "git pull" kullanın)
Getirmediyseniz ve git checkout master'ı yaptıysanız, yerel git'iniz 2 commit eklendiğini bilemezdi. Ve sadece şöyle derdi:
Zaten 'ustada'
Şubeniz 'menşe / ana' ile güncel.
Ancak bu modası geçmiş ve yanlış. Bunun nedeni, git'in size yalnızca bildiklerine dayalı olarak geribildirim vermesi. Henüz geri çekmediği yeni taahhütlerden habersiz ...
Şubede yerel olarak çalışırken uzaktan yapılan yeni değişiklikleri görmenin bir yolu var mı?
Bazı IDE'ler (örneğin Xcode) süper akıllıdır ve bir git getirmenin sonucunu kullanır ve mevcut çalışma dalınızın uzak dalında değiştirilen kod satırlarına açıklama ekleyebilir. Bu satır hem yerel değişiklikler hem de uzak şubeler tarafından değiştirilmişse, bu satıra kırmızı ile açıklama eklenir. Bu bir birleştirme çatışması değil. Potansiyel bir birleştirme çatışması. Uzak daldan git çekme yapmadan önce gelecekteki birleştirme çakışmasını çözmek için kullanabileceğiniz bir uyarıdır.
Eğlenceli ipucu:
Uzak bir şube getirdiyseniz, ör. yaptı:
git kaynak getirme özelliği / 123
Sonra bu, uzaktan kumandalar dizininize gider. Hala yerel dizininizde mevcut değil. Bununla birlikte, DWIM ile bu uzak şubeye ödeme işleminizi basitleştirir (Demek istediğimi yapın):
git ödeme özelliği / 123
artık yapmanız gerekmiyor:
git checkout -b özelliği / 123 orijin / özellik / 123
Bununla ilgili daha fazla bilgi için burayı okuyun
|
Git çekme ve git getirme arasındaki tek fark şudur:
git pull uzak bir daldan çeker ve onu birleştirir.
git fetch yalnızca uzak daldan alır, ancak birleşmez
ör. git çekme = git getir + git birleştirme ...
|
Git, kronolojik olarak daha eski kayıtların daha yeni kayıtlardan sonra uygulanmasına izin verir.
Bu nedenle, depolar arasında taahhütleri aktarma eylemi iki adıma bölünmüştür:
Uzak şubeden bu uzak şubenin yerel depo içindeki kopyasına yeni işlemlerin kopyalanması.
(repo'dan repo işlemine) master @ remote >> uzak / kaynak / ana @ yerel
Yerel şubeye yeni taahhütleri entegre etme
(repo içi işlem) uzak / kaynak / ana @ yerel >> ana @ yerel
2. adımı yapmanın iki yolu vardır: Şunları yapabilirsiniz:
Yerel şubeyi son ortak atadan sonra çatallayın ve yerel depoya özgü olan işlemlere paralel olarak yeni taahhütler ekleyin, commit birleştirilerek sonuçlandırılır, çatalı kapatılır.
Son ortak atadan sonra yeni işlemeler ekleyin ve yerel depoya benzersiz olarak yeniden kaydetme işlemleri uygulayın.
Git terminolojisinde 1. adım git fetch, 2. adım git merge veya git rebase'dir
git çekme, git getirme ve git birleştirme
|
Git, iki komut kullanarak en son sürümün dalını uzaktan yerel ağa alır:
git fetch: Git en son sürümü uzaktan yerele alacak, ancak otomatik olarak birleştirilmeyecek.

git kaynak ana getirme
git log -p usta..origin / usta
git birleştirme kaynağı / ana
Yukarıdaki komutlar, ana dalın en son sürümünün, uzaktaki kaynaktan ana ana dala indirilmesi anlamına gelir. Ve sonra yerel ana dalı ve başlangıç ​​ana dalı karşılaştırır. Son olarak birleştirin.
git pull: Git, uzaktan kumandadan en son sürümü alacak ve yerelde birleşecek.

git çekme kaynağı yöneticisi
Yukarıdaki komut git fetch ve git merge ile eşdeğerdir. Uygulamada, git getirme işlemi daha güvenli olabilir çünkü birleştirmeden önce değişiklikleri görebilir ve birleştirip birleştirmemeye karar verebiliriz.
|
Git çekme ve git getirme arasındaki fark nedir?
Bunu anlamak için, öncelikle yerel git'inizin yalnızca yerel deponuzu değil, aynı zamanda uzak deponun yerel bir kopyasını da tuttuğunu anlamanız gerekir.
git fetch, uzak deponun yerel kopyasını güncel hale getirir. Örneğin, uzak deponuz GitHub ise - uzak depoda yapılan değişiklikleri uzak depodaki yerel kopyanıza getirmek isteyebilirsiniz. Bu, karşılaştırma veya birleştirme gibi işlemleri gerçekleştirmenize izin verecektir.
Öte yandan git pull, uzak depodaki değişiklikleri kendi kodunuzu tuttuğunuz yere indirecektir. Genellikle git pull, uzak deponun yerel kopyasını güncellemek için önce bir git getirme işlemi gerçekleştirir ve ardından değişiklikleri kendi kod deponuzda ve muhtemelen çalışma kopyanızda birleştirir.
|
git çekme == (git getir + git birleştirme)
git fetch yerel dallarda değişiklik yapmaz.
İstenilen proje için uzaktan ayarlı yerel bir deponuz zaten varsa, mevcut uzaktan kumanda için tüm dalları ve etiketleri git fetch kullanarak alabilirsiniz. ... Getirme, yerel dallarda herhangi bir değişiklik yapmaz, bu nedenle, yeni getirme değişikliklerini dahil etmek için uzak bir dalı eşleştirilmiş bir yerel dalla birleştirmeniz gerekir. github'dan
|
Yeni Başlayanlar İçin Basit Bir Grafik Temsil,
buraya,
git çekme
kodu getirecekdepodan ve yerel ile yeniden temelden ... git pull'da yeni kayıtların yaratılma olasılığı vardır.
ama içinde
git getir
kodu depodan alacak ve git rebase kullanarak manuel olarak yeniden oluşturmamız gerekiyor
örneğin: sunucu yöneticisinden alıp yerel yöneticimde yeniden başlatacağım.
1) git çekme (yeniden ödeme otomatik olarak yapılacaktır):
git çekme kaynağı yöneticisi
burada orijin, uzak repo yöneticiniz şubenizdir
2) git getirme (manuel olarak yeniden oluşturmanız gerekir):
git kaynak ana getirme
sunucu değişikliklerini kaynağından alacaktır. ve siz kendi başınıza yeniden sunana kadar yerelde olacaktır. kodları kontrol ederek çakışmaları manuel olarak düzeltmemiz gerekir.
git rebase kaynağı / ana
bu, kodu yerel olarak yeniden düzenleyecektir. bundan önce doğru dalda olduğunuzdan emin olun.
|
Açık ve basit olmaya çalışıyorum.
Git pull komutu aslında git fetch için bir kısayoldur ve ardından yapılandırmanıza bağlı olarak git merge veya git rebase komutu gelir. Git deponuzu, git pull bir getirme ve ardından bir yeniden temel olacak şekilde yapılandırabilirsiniz.
|
Aslında Git kendi kodunuzun bir kopyasını tutar ve
uzak depo.
Git fetch komutu, uzak depodan veri alarak yerel kopyanızı güncel hale getirir. Buna ihtiyaç duymamızın nedeni, başka birinin kodda bazı değişiklikler yapmış olabileceği ve kendinizi güncel tutmak istemenizdir.
Git pull komutu, uzak depodaki değişiklikleri kendi kodunuzu tuttuğunuz yere getirir. Normalde git pull bunu önce uzak deponun yerel kopyasını güncellemek için bir "git getirme" yaparak yapar ve ardından değişiklikleri kendi kod deponuzda ve muhtemelen çalışma kopyanızda birleştirir.
|
1
2
Sonraki
Oldukça aktif soru. Bu soruyu cevaplamak için 10 itibar kazanın. İtibar koşulu, bu sorunun istenmeyen postalardan ve yanıtlanmayan etkinliklerden korunmasına yardımcı olur.
Aradığın cevap değil mi? Git version-control git-pull git-fetch etiketli diğer sorulara göz atın veya kendi sorunuzu sorun.